package cn.easyutil.util.javaUtil;

import cn.easyutil.util.javaUtil.http.HttpOperation;
import cn.easyutil.util.javaUtil.http.HttpReq;
import cn.easyutil.util.javaUtil.http.HttpUtilFactory;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

/**
 * 二进制权限控制工具类
 * @author spc
 *
 */
public class BinaryAuthUtil {

	/**
	 * 添加权限
	 * @param own	原有权限
	 * @param add	要增加的权限
	 * @return	增加后的权限
	 */
	public static long addAuth(long own,long add){
		return own | add;
	}
	
	/**
	 * 批量添加权限
	 * @param own	原有权限
	 * @param add	要增加的权限
	 * @return	增加后的权限
	 */
	public static long addAuth(long own,List<Long> add){
		for (long auth : add) {
			own = addAuth(own, auth);
		}
		return own;
	}
	
	/**
	 * 批量添加权限
	 * @param own	原有权限
	 * @param add	要增加的权限
	 * @return	增加后的权限
	 */
	public static long addAuth(int own,List<Integer> add){
		for (int auth : add) {
			own = addAuth(own, auth);
		}
		return own;
	}
	
	/**
	 * 添加权限
	 * @param own	原有权限
	 * @param add	要增加的权限
	 * @return	增加后的权限
	 */
	public static int addAuth(int own,int add){
		return own | add;
	}
	
	/**
	 * 判断是否拥有该权限
	 * @param own	原有权限
	 * @param auth	对比权限
	 * @return	true:拥有   false:未拥有
	 */
	public static boolean hasAuth(long own,long auth){
		return (own|auth) == own;
	}
	
	/**
	 * 判断是否拥有该权限
	 * @param own	原有权限
	 * @param auth	对比权限
	 * @return	true:拥有   false:未拥有
	 */
	public static boolean hasAuth(int own,int auth){
		return (own|auth) == own;
	}
	
	/**
	 * 判断是否拥有所有权限
	 * @param own	原有权限
	 * @param auths	对比权限
	 * @return	true:拥有   false:未拥有
	 */
	public static boolean hasAuth(long own,List<Long> auths){
		for (long auth : auths) {
			if(!hasAuth(own, auth)){
				return false;
			}
		}
		return true;
	}
	
	/**
	 * 判断是否拥有所有权限
	 * @param own	原有权限
	 * @param auths	对比权限
	 * @return	true:拥有   false:未拥有
	 */
	public static boolean hasAuth(int own,List<Integer> auths){
		for (int auth : auths) {
			if(!hasAuth(own, auth)){
				return false;
			}
		}
		return true;
	}
	
	/**
	 * 判断是否拥有其中一个权限
	 * @param own	原有权限
	 * @param auths	对比权限
	 * @return	true:拥有   false:未拥有
	 */
	public static boolean hasOneAuth(long own,List<Long> auths){
		for (long auth : auths) {
			if(hasAuth(own, auth)){
				return true;
			}
		}
		return false;
	}
	
	/**
	 * 判断是否拥有其中一个权限
	 * @param own	原有权限
	 * @param auths	对比权限
	 * @return	true:拥有   false:未拥有
	 */
	public static boolean hasOneAuth(int own,List<Integer> auths){
		for (int auth : auths) {
			if(hasAuth(own, auth)){
				return true;
			}
		}
		return false;
	}
	
	/**
	 * 判断权限，取出相同
	 * @param own	原有权限
	 * @param auths	对比权限
	 * @return	相同的权限
	 */
	public static List<Long> compareEq(long own,List<Long> auths){
		List<Long> result = new ArrayList<Long>();
		for (long auth : auths) {
			if(hasAuth(own, auth)){
				result.add(auth);
			}
		}
		return result;
	}
	
	/**
	 * 判断权限，取出相同
	 * @param own	原有权限
	 * @param auths	对比权限
	 * @return	相同的权限
	 */
	public static List<Integer> compareEq(int own,List<Integer> auths){
		List<Integer> result = new ArrayList<Integer>();
		for (int auth : auths) {
			if(hasAuth(own, auth)){
				result.add(auth);
			}
		}
		return result;
	}
	
	/**
	 * 判断权限，取出不相同
	 * @param own	原有权限
	 * @param auths	对比权限
	 * @return	不相同的权限
	 */
	public static List<Long> compareNotEq(long own,List<Long> auths){
		List<Long> result = new ArrayList<Long>();
		for (long auth : auths) {
			if(!hasAuth(own, auth)){
				result.add(auth);
			}
		}
		return result;
	}
	
	/**
	 * 判断权限，取出不相同
	 * @param own	原有权限
	 * @param auths	对比权限
	 * @return	不相同的权限
	 */
	public static List<Integer> compareNotEq(int own,List<Integer> auths){
		List<Integer> result = new ArrayList<Integer>();
		for (int auth : auths) {
			if(!hasAuth(own, auth)){
				result.add(auth);
			}
		}
		return result;
	}
	
	/**
	 * 取消某权限
	 * @param own	原有权限
	 * @param auth	要取消的权限
	 * @return	取消后的权限
	 */
	public static long cancelAuth(long own,long auth){
		return (own|auth)-auth;
	}
	
	/**
	 * 批量取消某权限
	 * @param own	原有权限
	 * @param add	要取消的权限
	 * @return	取消后的权限
	 */
	public static long cancelAuth(long own,List<Long> add){
		for (long auth : add) {
			own = cancelAuth(own, auth);
		}
		return own;
	}
	
	/**
	 * 批量取消某权限
	 * @param own	原有权限
	 * @param add	要取消的权限
	 * @return	取消后的权限
	 */
	public static long cancelAuth(int own,List<Integer> add){
		for (int auth : add) {
			own = cancelAuth(own, auth);
		}
		return own;
	}
	
	/**
	 * 取消某权限
	 * @param own	原有权限
	 * @param auth	要取消的权限
	 * @return	取消后的权限
	 */
	public static int cancelAuth(int own,int auth){
		return (own|auth)-auth;
	}
	
	/**
	 * 获取所有权限
	 * @param own	权限码
	 * @return	权限列表
	 */
	public static List<Long> getAuths(long own){
		List<Long> auths = new ArrayList<Long>();
		String bs = Long.toBinaryString(own);
		bs = new StringBuffer(bs).reverse().toString();
		for (int j = 0; j < bs.length(); j++) {
			if(bs.charAt(j) == '0'){
				continue;
			}
			double dou = Math.pow(2, j);
			auths.add(new BigDecimal(dou).longValue());
		}
		return auths;
	}
	
	
	/**
	 * 获取所有权限
	 * @param own	权限码
	 * @return	权限列表
	 */
	public static List<Integer> getAuths(int own){
		List<Integer> auths = new ArrayList<Integer>();
		String bs = Integer.toBinaryString(own);
		bs = new StringBuffer(bs).reverse().toString();
		for (int j = 0; j < bs.length(); j++) {
			if(bs.charAt(j) == '0'){
				continue;
			}
			double dou = Math.pow(2, j);
			auths.add(new BigDecimal(dou).intValue());
		}
		return auths;
	}

}
